package Underworld_Survival;

import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;

// 效果值统一接口（所有效果必须实现）
@FunctionalInterface
interface EffectValue {
    /**
     * 获取效果值（固定值可忽略context参数）
     * @param context 角色上下文（可为null）
     */
    float getValue(Role context);
}

// 固定数值效果（忽略context参数）
record FixedValue(float value) implements EffectValue {
    @Override
    public float getValue(Role context) {
        return value; // 不依赖上下文
    }

    // 语法糖方法（可选）
    public static EffectValue of(float value) {
        return new FixedValue(value);
    }
}

// 动态计算效果（通过Lambda实现）
class DynamicValue implements EffectValue, Serializable {
    private final EffectCalculator calculator;
    private static final long serialVersionUID = 1L;

    // 函数式接口定义
    @FunctionalInterface
    public interface EffectCalculator {
        float calculate(Role context);
    }

    public DynamicValue(EffectCalculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public float getValue(Role context) {
        return calculator.calculate(context);
    }

    // 使用序列化代理模式
    private Object writeReplace() {
        return new SerializationProxy(this);
    }

    private void readObject(ObjectInputStream stream)
            throws InvalidObjectException {
        throw new InvalidObjectException("请使用代理序列化");
    }

    // 序列化代理
    private static class SerializationProxy implements Serializable {
        private final String formula;

        SerializationProxy(DynamicValue original) {
            // 实际项目应提取公式逻辑
            this.formula = "BASE_STR*0.15";
        }

        private Object readResolve() {
            return new DynamicValue(context ->
                    context.getBaseStr() * 0.15f
            );
        }
    }


    // 语法糖方法（可选）
    public static EffectValue of(EffectCalculator calculator) {
        return new DynamicValue(calculator);
    }
}